אוניברסיטת בן-גוריון מדור בחינות רשמו תשובותיכם בגיליון התשובות בלבד תשובות מחוץ לגיליון לא יבדקו. שימו לב: על תשובות ריקות יינתן 20% מהניקוד! בהצלחה!

Size: px

Start display at page:

Download "אוניברסיטת בן-גוריון מדור בחינות רשמו תשובותיכם בגיליון התשובות בלבד תשובות מחוץ לגיליון לא יבדקו. שימו לב: על תשובות ריקות יינתן 20% מהניקוד! בהצלחה!"

Gertrude Garrett
5 years ago
Views:

אוניברסיטת בן-גוריון מדור בחינות מספר נבחן: רשמו תשובותיכם בגיליון התשובות בלבד תשובות מחוץ לגיליון לא יבדקו. שימו לב: על תשובות ריקות יינתן 20% מהניקוד! בהצלחה! תאריך הבחינה: 09.02.

1 אוניברסיטת בן-גוריון מדור בחינות מספר נבחן: רשמו תשובותיכם בגיליון התשובות בלבד תשובות מחוץ לגיליון לא יבדקו. שימו לב: על תשובות ריקות יינתן 20% מהניקוד! בהצלחה! תאריך הבחינה: שם המורה: ד"ר אנדרי שרף ד"ר רן אטינגר ד"ר ג'ון מרברג ד"ר מני אדלר שם הקורס: תכנות מערכות מספר הקורס: מיועד לתלמידי: מדעי המחשב, הנדסת תוכנה שנה: תשע"ה סמסטר: א' מועד: א' משך הבחינה: שלש שעות חומר עזר: אסור 30( שאלה 1 נקודות( גלגלי שיניים הינם רכיבים אלמנטריים בכל מכונה מודרנית. ראשיתם במכונות שהמציא ארכימדס, אי שם במאה השלישית לפני הספירה. בצמד גלגלי שיניים, כאשר גלגל אחד מסתובב לכיוון מסוים, הגלגל השני מסתובב בכיוון ההפוך. מערכת גלגלי שיניים, הנקראת גם תמסורת, כוללת פעמים רבות גלגלי שיניים בגדלים שונים. בשאלה זו נעסוק בסימולציה פשוטה של מערכת גלגלי שיניים. הממשק Gear מגדיר גלגל שיניים ע"פ נקודות המרכז שלו )קואורדינטות,)x,y אורך הרדיוס, ושני גלגלי השיניים שמצידו הימני והשמאלי )לפי הקואורדינטה x, כאשר קואורדינטת y אינה בהכרח זהה(. כמו כן מגדיר הממשק את המתודה,move המסובבת את הגלגל בכיוון הנתון )עם או נגד כיוון השעון(, ואת הגלגלים משני צדדיו בכיוון ההפוך. interface Gear { float getx(); // returns the x coordinate of the center float gety(); // returns the y coordinate of the center float getradius(); // returns the length of the radius Gear getleft(); // returns the gear on the left Gear getright(); // returns the gear on the right void move(boolean clockwise); // advance the gear and both its neighbors void moveleft(boolean clockwise); // advance the gear and its left neighbor void moveright(boolean clockwise); // advance the gear and its right neighbor א. הגדירו תכונה נשמרת )invariant( עבור הממשק להלן מימוש של הממשק )5 נקודות( Gear 1

2 class SimpleGear implements Gear { final float _x,_y,_radius; Gear _left, _right; SimpleGear(float x, float y, float radius) throws Exception { if (!check(x,y,radius)) throw new Exception("Wrong parameter values!"); _x = x; _y = y; _radius = radius; _left = null; _right = null; public float getx() { return _x; public float gety() { return _y; public float getradius() { return _radius; public Gear getleft() { return _left; public Gear getright() { return _right; public void setleft(gear left) throws Exception { if (_left!= null) throw new Exception("Left gear is already defined"); if (!check(left. true)) throw new Exception("Wrong gear position!"); _left = left; public void setright(gear right) throws Exception { if (_right!= null) throw new Exception("Right gear is already defined"); if (!check(right,false)) throw new Exception("Wrong gear position!"); _right = right; public void move(boolean clockwise) { if (_left!= null) getleft().moveleft(!clockwise); if (_right!= null) getright().moveright(!clockwise); public void moveleft(boolean clockwise) { if (_left!= null) getleft().moveleft(!clockwise); public void moveright(boolean clockwise) { if (_right!= null) getright().moveright(!clockwise); 2

3 protected boolean check(float x, float y, float radius) { //@TODO protected boolean check(gear other, Boolean whichside) { //whichside indicates left-side (true) or right-side (false) //@TODO check ב. ג. השלימו את שתי המתודות בסעיף א )2 נקודות( הבודקות את תקינות פרמטרי האתחול, ע"פ התכונה הנשמרת שציינתם בהנחה שמימוש המתודות check נכון, האם המחלקה בטוחה תחת כל חישוב מקבילי אפשרי? אם לא, הראו תרחיש מתאים. אם כן, נמקו בקצרה )4 נקודות( למחלקה SimpleGear נוסף כעת שדה חדש _state המאפיין את מצב גלגל השיניים על ידי מספר ממשי המציין את הזווית שלו )כך שהערך הוא בין 0 ל 360(. המצב ההתחלתי הוא 0. תזוזה בכיוון או נגד כיוון השעון מעלה או מורידה את הערך בהתאם, כפי שנוסף למתודות moveright,moveleft,move ]גודל התזוזה של גלגל השיניים תלוי ברדיוס שלו, כפי שמחושב ע"י המתודה הסטטית getoffset אופן מימושה אינו רלבנטי כאן[ class SimpleGear implements Gear { final float _x,_y,_radius; Gear _left, _right; float _state; SimpleGear(float x, float y, float radius) throws Exception { if (!check(x,y,radius)) throw new Exception("Wrong parameter values!"); _x = x; _y = y; _radius = radius; _left = null; _right = null; _state = 0; public void move(boolean clockwise) { float offset = getoffset(_radius); if (clockwise) _state = (_state + offset) % 360; else _state = (_state - offset) % 360; if (_left!= null) getleft().moveleft(!clockwise); if (_right!= null) getright().moveright(!clockwise); 3

4 public void moveleft(boolean clockwise) { float offset = getoffset(_radius); if (clockwise) _state = (_state + offset) % 360; else _state = (_state - offset) % 360; if (_left!= null) getleft().moveleft(!clockwise); public void moveright(boolean clockwise) { float offset = getoffset(_radius); if (clockwise) _state = (_state + offset) % 360; else _state = (_state - offset) % 360; if (_right!= null) getright().moveright(!clockwise); protected static float getoffset(float radius) { // calculates the offset of a gear with a given radius // the implementation is not relevant for the question ד. עדכנו את התכונה הנשמרת. האם כעת המחלקה בטוחה תחת כל חישוב מקבילי אפשרי? אם לא, הראו תרחיש מתאים. אם כן, נמקו בקצרה )5 נקודות( )4 נקודות( move ה. הגדירו תנאי התחלה וסיום למתודה נתונה מערכת המסמלצת מנגנון פשוט של גלגלי שיניים: class Spinner implements Runnable { Gear _gear; boolean _clockwise; Spinner(Gear gear, boolean clockwise) { _gear = gear; _clockwise = clockwise; 4

5 public void run() { for (int i=0;i<10; i++) { _gear.move(_clockwise); Thread.sleep(1000); catch (InterruptedException e) { class Simulation { public static void main(string[] args) throws Exception { SimpleGear gear1 = new SimpleGear(10,10,5); SimpleGear gear2 = new SimpleGear(20,10,5); SimpleGear gear3 = new SimpleGear(30,10,5); gear2.setleft(gear1); gear2.setright(gear3); gear1.setright(gear2); gear3.setleft(gear2); new Thread(new Spinner(gear2,true)).start(); new Thread(new Spinner(gear2,false)).start(); ו. האם הרצת המערכת נכונה? )בבדיקת קריטריון הנכונות, כהתאמת סדרת המצבים האפשרית עבור הרצה בסדר כל שהוא של פעולות, התייחסו להפעלת המתודה move כפעולה(. במידה ולא, תקנו את הקוד כך שיבטיח נכונות. )10 נקודות(. 30( שאלה 2 נקודות( וקטור )vector( הינו מבנה אחסון אשר מחזיק מערך )array( באופן סדרתי בזיכרון. התכונה המיוחדת של וקטור היא שניתן להגדיל ולהקטין אותו )resize( באופן דינאמי על פי הצורך. לאחר שהתברר כי המחלקה std::vector בזבזנית ביחס להקצאות זיכרון, הוחלט לממש מחלקה חדשה בשם mvector באמצעות רשימה מקושרת, הדואגת שהזיכרון הנצרך על ידי הווקטור הוא בדיוק בגודל הנדרש על מנת לאחסן את הנתונים. א. ממשו את פונקציות המחלקה.mvector ניתן להוסיף פונקציות עזר אך אין להוסיף שדות או לשנות חתימות של פונקציות קיימות. הגישה לאיבר ברשימה מקושרת אינה ב- (1)O כפי שבמערך. הפונקציה insertat מכניסה איבר במיקום,pos תמיד מצליחה, ומקצה זיכרון אם נדרש. הפונקציה removeat מוציאה איבר במיקום,pos ומקטינה את המבנה בהתאם. במידה ואין איבר במיקום זה, יוחזר איבר ריק כלשהו: )15 T dummy נקודות(. template <class T> class node { public: node(); node(const T &val); ~node(); 5

6 private: ; const T& _data; node *_next; template <class T> class mvector { public: mvector(); ~mvector(); mvector(const mvector &); void operator=(const mvector &); unsigned getsize(); void insertat(const T &, unsigned pos); const T & removeat(unsigned pos); private: unsigned _len; node<t> *_head; ; ב. יוסי, הסטודנט המצטיין ב SPL הציע לחסוך עוד זיכרון ולהוריד את השדה _len ובמקומו להשתמש ב.sizeof(_head) מה דעתך על הפתרון של יוסי? בחר את התשובה המתאימה ביותר )5 נקודות(:.template הפתרון מחזיר את גודל המערך, לכן עובד ונכון הפתרון כמעט נכון. יש לתקן ל: הפתרון מחזיר תמיד 4 במערכת של 32 ביט לא יתקמפל מכיוון שלא ניתן להשתמש ב אף תשובה לא נכונה sizeof(_head)/sizeof(t) sizeof() עם ג. ציירו את תמונת הזכרון )stack,heap,v-table( עבור הרצת קטע הקוד הבא עד ההערה )10 נקודות(: template <class T> void foo(mvector<t> vec){ mvector<t> my_vec = vec; //*****here***** void main(){ mvector<int> *vec = new mvector<int>; int val = 0; vec->insertat(val,5); foo(*vec); 6

7 30( שאלה 3 נקודות( צוות הפיתוח של חברת הזנק נחשבת החליט לעדכן את שרת ה Echo ע"פ תבנית הריאקטור שנלמדה בכיתה, כך שהתקשורת עם הלקוחות תבוסס על פרוטוקול,UDP במקום פרוטוקול TCP בקוד הקיים. DatagramSocketChannel הינה גרסה של ניתן לייצר הינה גרסה של המממשת גם DatagramSocket המממשת גם SelectableChannel )כפי ש SocketChannel.)SelectableChannel Socket DatagramSocketChannel port על נתון באופן הבא: int port = 7000; DatagramSocketChannel dgchannel = DatagramSocketChannel.open(); dgchannel.socket().bind(new InetSocketAddress(port));.receive,send בעזרת המתודות ByteBuffer תומך בשליחה וקבלה של DatagramSocketChannel אם ה DatagramSocketChannel מוגדר כ :non-blocking שליחה: או שכל ה packet נשלח מיד )כך שהערך המוחזר הוא מספר הבתים שנועדו לשליחה(, או שלא נשלח כלום )כך שהערך המוחזר הוא 0(. קבלה : או שכל ה packet מתקבל מיד, או שלא מתקבל כלום. מתודת ה receive מחזירה את כתובת השולח אם כל ה packet נקרא אל תוך ה,ByteBuffer או מחזירה null אם לא ניתן היה לקרוא את כל ה.packet להלן התיאור הרשמי של מתודות אלו: public int send(bytebuffer src, SocketAddress target) throws IOException Sends a datagram via this channel. Parameters: src - The buffer containing the datagram to be sent target - The address to which the datagram is to be sent Returns: The number of bytes sent, which will be either the number of bytes that were remaining in the source buffer when this method was invoked or, if this channel is non-blocking, may be zero if there was insufficient room for the datagram in the underlying output buffer public SocketAddress receive(bytebuffer dst) throws IOException Receives a datagram via this channel. Parameters: dst - The buffer into which the datagram is to be transferred Returns: The datagram's source address, or null if this channel is in non-blocking mode and no datagram was immediately available א. ממשו את ההצעה של צוות הפיתוח באמצעות,DatagramSocketChannel כאשר DatagramSocketChannel יחיד משמש לתקשורת עם כל הלקוחות. קוד הריאקטור המקורי מופיע בנספח. ניתן להוסיף מתודות ומחלקות. אין צורך לכתוב מתודות קיימות מחדש בגיליון התשובות ציינו את המקום במתודה בו אתם עורכים שינוי ואת השינוי )20 נקודות(. UDP במקום 2( TCP נקודות(. ב. ענו בקצרה על השאלות הבאות: I ציינו יתרון וחסרון עבור ההחלטה לעבור ל האם ניתן לעצב את ה Reactor המקורי עם SocketChannel יחיד לכל הלקוחות, כפי שנעשה עם DatagramSocketChannel במימוש שלכם בסעיף א'? נמקו )3 נקודות(. האם לדעתכם הגדרת )ביחס למימוש מסעיף א' בו יש רק DatagramSocketChannel נפרד לכל לקוח תייעל את התקשורת עם הלקוחות DatagramSocketChannel אחד(? נמקו )5 נקודות(. II III 7

8 10( שאלה 4 נקודות( חברת הסלולר BigApple נוהגת לאחסן נתונים על לקוחותיה ועל הפעולות שהם מבצעים במכשיר הנייד שלהם. עבור כל לקוח נשמרים נתוני שמו, מספר הטלפון שלו, תאריך הצטרפות, וכן קישורים לבני משפחתו, המנויים אף הם בחברת.BigApple כל פעולה הקשורה ללקוח נשמרת עם תאריך הביצוע שלה. קיימים סוגים שונים של פעולות: שליחת הודעה למספר מסויים, קבלת הודעה ממספר מסויים, התקשרות למספר מסויים, שיחה שלא נענתה ממספר מסויים. א. הגדירו מודל נתונים עבור המידע אותו שומרת חברת הסלולר. SQL המחזירה את ההודעות שנתקבלו עבור בני משפחתו הענפה של רינגו סטאר. ב. כתבו שאילתת 8

9 נספח: קוד ה,Reactor כפי שנלמד בכיתה ובתרגול public class Reactor<T> implements Runnable { private static final Logger logger = Logger.getLogger("edu.spl.reactor"); private final int _port; private final int _poolsize; private final ServerProtocolFactory<T> _protocolfactory; private final TokenizerFactory<T> _tokenizerfactory; private volatile boolean _shouldrun = true; private ReactorData<T> _data; public Reactor(int port, int poolsize, ServerProtocolFactory<T> protocol, TokenizerFactory<T> tokenizer) { _port = port; _poolsize = poolsize; _protocolfactory = protocol; _tokenizerfactory = tokenizer; private ServerSocketChannel createserversocket(int port) throws IOException { ServerSocketChannel sschannel = ServerSocketChannel.open(); sschannel.configureblocking(false); sschannel.socket().bind(new InetSocketAddress(port)); return sschannel; catch (IOException e) { logger.info("port " + port + " is busy"); throw e; public void run() { ExecutorService executor = Executors.newFixedThreadPool(_poolSize); Selector selector = null; ServerSocketChannel sschannel = null; selector = Selector.open(); sschannel = createserversocket(_port); catch (IOException e) { logger.info("cannot create the selector -- server socket is busy?"); return; 9

10 _data = new ReactorData<T>(executor, selector, _protocolfactory, _tokenizerfactory); ConnectionAcceptor<T> connectionacceptor = new ConnectionAcceptor<T>( sschannel, _data); sschannel.register(selector, SelectionKey.OP_ACCEPT, connectionacceptor); catch (ClosedChannelException e) { logger.info("server channel seems to be closed!"); return; while (_shouldrun && selector.isopen()) { selector.select(); catch (IOException e) { logger.info("trouble with selector: " + e.getmessage()); continue; Iterator<SelectionKey> it = selector.selectedkeys().iterator(); while (it.hasnext()) { SelectionKey selkey = (SelectionKey) it.next(); it.remove(); if (selkey.isvalid() && selkey.isacceptable()) { logger.info("accepting a connection"); ConnectionAcceptor<T> acceptor = (ConnectionAcceptor<T>) selkey.attachment(); acceptor.accept(); catch (IOException e) { logger.info("problem accepting a new connection: " + e.getmessage()); continue; if (selkey.isvalid() && selkey.isreadable()) { ConnectionHandler<T> handler = (ConnectionHandler<T>) selkey.attachment(); logger.info("channel is ready for reading"); handler.read(); if (selkey.isvalid() && selkey.iswritable()) { ConnectionHandler<T> handler = (ConnectionHandler<T>) selkey.attachment(); logger.info("channel is ready for writing"); handler.write(); 10

11 stopreactor(); public int getport() { return _port; public synchronized void stopreactor() { if (!_shouldrun) return; _shouldrun = false; _data.getselector().wakeup(); _data.getexecutor().shutdown(); _data.getexecutor().awaittermination(2000, TimeUnit.MILLISECONDS); catch (InterruptedException e) { e.printstacktrace(); public static void main(string args[]) { if (args.length!= 2) { System.err.println("Usage: java Reactor <port> <pool_size>"); System.exit(1); int port = Integer.parseInt(args[0]); int poolsize = Integer.parseInt(args[1]); Reactor<StringMessage> reactor = startechoserver(port, poolsize); Thread thread = new Thread(reactor); thread.start(); logger.info("reactor is ready on port " + reactor.getport()); thread.join(); catch (Exception e) { e.printstacktrace(); public static Reactor<StringMessage> startechoserver(int port, int poolsize){ ServerProtocolFactory<StringMessage> protocolmaker = new ServerProtocolFactory<StringMessage>() { public AsyncServerProtocol<StringMessage> create() { return new EchoProtocol(); ; 11

12 final Charset charset = Charset.forName("UTF-8"); TokenizerFactory<StringMessage> tokenizermaker = new TokenizerFactory<StringMessage>() { public MessageTokenizer<StringMessage> create() { return new FixedSeparatorMessageTokenizer("\n", charset); ; Reactor<StringMessage> reactor = new Reactor<StringMessage>(port, poolsize, protocolmaker, tokenizermaker); return reactor; Reactor<HttpMessage> reactor = new Reactor<HttpMessage>(port, poolsize, protocolmaker, tokenizermaker); return reactor; public class ConnectionAcceptor<T> { protected ServerSocketChannel _sschannel; protected ReactorData<T> _data; public ConnectionAcceptor(ServerSocketChannel sschannel, ReactorData<T> data) { _sschannel = sschannel; _data = data; public void accept() throws IOException { SocketChannel schannel = _sschannel.accept(); if (schannel!= null) { SocketAddress address = schannel.socket().getremotesocketaddress(); System.out.println("Accepting connection from " + address); schannel.configureblocking(false); SelectionKey key = schannel.register(_data.getselector(), 0); ConnectionHandler<T> handler = ConnectionHandler.create(sChannel, _data, key); handler.switchtoreadonlymode(); public class ConnectionHandler<T> { private static final int BUFFER_SIZE = 1024; 12

13 protected final SocketChannel _schannel; protected final ReactorData<T> _data; protected final AsyncServerProtocol<T> _protocol; protected final MessageTokenizer<T> _tokenizer; protected Vector<ByteBuffer> _outdata = new Vector<ByteBuffer>(); protected final SelectionKey _skey; private static final Logger logger = Logger.getLogger("edu.spl.reactor"); private ProtocolTask<T> _task = null; private ConnectionHandler(SocketChannel schannel, ReactorData<T> data, SelectionKey key) { _schannel = schannel; _data = data; _skey = key; _protocol = _data.getprotocolmaker().create(); _tokenizer = _data.gettokenizermaker().create(); private void initialize() { _skey.attach(this); _task = new ProtocolTask<T>(_protocol, _tokenizer, this); public static <T> ConnectionHandler<T> create(socketchannel schannel, ReactorData<T> data, SelectionKey key) { ConnectionHandler<T> h = new ConnectionHandler<T>(sChannel, data, key); h.initialize(); return h; public synchronized void addoutdata(bytebuffer buf) { _outdata.add(buf); switchtoreadwritemode(); private void closeconnection() { _skey.cancel(); _schannel.close(); catch (IOException ignored) { ignored = null; public void read() { if (_protocol.shouldclose()) return; SocketAddress address = _schannel.socket().getremotesocketaddress(); 13

14 logger.info("reading from " + address); ByteBuffer buf = ByteBuffer.allocate(BUFFER_SIZE); int numbytesread = 0; numbytesread = _schannel.read(buf); catch (IOException e) { numbytesread = -1; if (numbytesread == -1) { logger.info("client on " + address + " has disconnected"); closeconnection(); _protocol.connectionterminated(); return; buf.flip(); _task.addbytes(buf); _data.getexecutor().execute(_task); public synchronized void write() { if (_outdata.size() == 0) { switchtoreadonlymode(); return; ByteBuffer buf = _outdata.remove(0); if (buf.remaining()!= 0) { _schannel.write(buf); catch (IOException e) { e.printstacktrace(); if (buf.remaining()!= 0) { _outdata.add(0, buf); if (_protocol.shouldclose()) { switchtowriteonlymode(); if (buf.remaining() == 0) { closeconnection(); SocketAddress address = _schannel.socket().getremotesocketaddress(); logger.info("disconnecting client on " + address); 14

15 public void switchtoreadwritemode() { _skey.interestops(selectionkey.op_read SelectionKey.OP_WRITE); _data.getselector().wakeup(); public void switchtoreadonlymode() { _skey.interestops(selectionkey.op_read); _data.getselector().wakeup(); public void switchtowriteonlymode() { _skey.interestops(selectionkey.op_write); _data.getselector().wakeup(); public class ProtocolTask<T> implements Runnable { private final ServerProtocol<T> _protocol; private final MessageTokenizer<T> _tokenizer; private final ConnectionHandler<T> _handler; public ProtocolTask(final ServerProtocol<T> protocol, final MessageTokenizer<T> tokenizer, final ConnectionHandler<T> h) { this._protocol = protocol; this._tokenizer = tokenizer; this._handler = h; public synchronized void run() { while (_tokenizer.hasmessage()) { T msg = _tokenizer.nextmessage(); T response = this._protocol.processmessage(msg); if (response!= null) { ByteBuffer bytes = _tokenizer.getbytesformessage(response); this._handler.addoutdata(bytes); catch (CharacterCodingException e) { e.printstacktrace(); public void addbytes(bytebuffer b) { _tokenizer.addbytes(b); 15

16 class FixedSeparatorMessageTokenizer implements MessageTokenizer<StringMessage> { private final String _messageseparator; private final StringBuffer _stringbuf = new StringBuffer(); private final Vector<ByteBuffer> _buffers = new Vector<ByteBuffer>(); private final CharsetDecoder _decoder; private final CharsetEncoder _encoder; public FixedSeparatorMessageTokenizer(String separator, Charset charset) { this._messageseparator = separator; this._decoder = charset.newdecoder(); this._encoder = charset.newencoder(); public synchronized void addbytes(bytebuffer bytes) { _buffers.add(bytes); public synchronized boolean hasmessage() { while(_buffers.size() > 0) { ByteBuffer bytes = _buffers.remove(0); CharBuffer chars = CharBuffer.allocate(bytes.remaining()); this._decoder.decode(bytes, chars, false); chars.flip(); this._stringbuf.append(chars); return this._stringbuf.indexof(this._messageseparator) > -1; public synchronized StringMessage nextmessage() { String message = null; int messageend = this._stringbuf.indexof(this._messageseparator); if (messageend > -1) { message = this._stringbuf.substring(0, messageend); this._stringbuf.delete(0, messageend+this._messageseparator.length()); return new StringMessage(message); public ByteBuffer getbytesformessage(stringmessage msg) throws CharacterCodingException { StringBuilder sb = new StringBuilder(msg.getMessage()); sb.append(this._messageseparator); 16

17 ByteBuffer bb = this._encoder.encode(charbuffer.wrap(sb)); return bb; public class EchoProtocol implements AsyncServerProtocol<StringMessage> { private boolean _shouldclose = false; private boolean _connectionterminated = false; public StringMessage processmessage(stringmessage msg) { if (this._connectionterminated) { return null; if (this.isend(msg)) { this._shouldclose = true; return new StringMessage("Ok, bye bye"); return new StringMessage("Your message \"" + msg + "\" has been received"); public boolean isend(stringmessage msg) { return msg.equals("bye"); public boolean shouldclose() { return this._shouldclose; public void connectionterminated() { this._connectionterminated = true; 17

SPL - PS12. Reactor and Java New-IO (nio) classes

SPL - PS12. Reactor and Java New-IO (nio) classes SPL - PS12 Reactor and Java New-IO (nio) classes Multi-Threaded server, as seen in Tirgul 11 - one thread is in charge of accepting new connections - opens a new thread for each new client. - Thus, handling